home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Edition 10 / FreelogHS10.iso / Buzz / Buzz_Advanced_Pack.exe / {app} / Dev / Noise.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-27  |  5.7 KB  |  316 lines
  1. #include <string.h>
  2. #include <stdlib.h>
  3. #include <assert.h>
  4. #include <math.h>
  5. #include "MachineInterface.h"
  6.  
  7. CMachineParameter const paraLDelay = 
  8. { 
  9.     pt_word,                                        // Type
  10.     "Left Delay",                                    // Short Description
  11.     "Left Delay (Ticks/16)",                        // Long Description
  12.     0x0001,                                            // MinValue    
  13.     0x0400,                                            // MaxValue
  14.     0x0401,                                            // NoValue
  15.     MPF_STATE,                                        // Flags
  16.     96,                                                // Default Value
  17. };
  18.  
  19. CMachineParameter const paraLFB = 
  20. {
  21.     pt_word,
  22.     "L Feedback",
  23.     "Left Feedback",
  24.     0x0000,
  25.     0x0190,
  26.     0x0191,
  27.     MPF_STATE,
  28.     0x00fa,
  29. };
  30.  
  31. CMachineParameter const paraRDelay = 
  32. { 
  33.     pt_word,                                        // Type
  34.     "Right Delay",                                    // Short Description
  35.     "Right Delay (Ticks/16)",                        // Long Description
  36.     0x0001,                                            // MinValue    
  37.     0x0400,                                            // MaxValue
  38.     0x0401,                                            // NoValue
  39.     MPF_STATE,                                        // Flags
  40.     96,                                                // Default Value
  41. };
  42.  
  43. CMachineParameter const paraRFB = 
  44. {
  45.     pt_word,
  46.     "R Feedback",
  47.     "Right Feedback",
  48.     0x0000,
  49.     0x0190,
  50.     0x0191,
  51.     MPF_STATE,
  52.     0x00fa,
  53. };
  54.  
  55. CMachineParameter const paraDryAmt = 
  56. {
  57.     pt_byte,
  58.     "Dry Thru",
  59.     "Dry Through Amount",
  60.     0,
  61.     200,
  62.     201,
  63.     MPF_STATE,
  64.     100,
  65. };
  66.  
  67. CMachineParameter const paraXOver = 
  68. {
  69.     pt_word,
  70.     "X-Delay Amt",
  71.     "Cross Over Amount",
  72.     0,
  73.     400,
  74.     401,
  75.     MPF_STATE,
  76.     250,
  77. };
  78.  
  79. CMachineParameter const paraLIn = 
  80. {
  81.     pt_word,
  82.     "Left In",
  83.     "Left Input Amount",
  84.     0,
  85.     400,
  86.     401,
  87.     MPF_STATE,
  88.     250,
  89. };
  90.  
  91. CMachineParameter const paraRIn = 
  92. {
  93.     pt_word,
  94.     "Right In",
  95.     "Right Input Amount",
  96.     0,
  97.     400,
  98.     401,
  99.     MPF_STATE,
  100.     250,
  101. };
  102.  
  103. CMachineParameter const *pParameters[] =            // Array of Parameters
  104. { 
  105.     ¶LDelay,
  106.     ¶LFB,
  107.     ¶RDelay,
  108.     ¶RFB,
  109.     ¶DryAmt,
  110.     ¶XOver,
  111.     ¶LIn,
  112.     ¶RIn,
  113. };
  114.  
  115. #pragma pack(1)                                        // Place to retrieve parameters    
  116.  
  117. class gvals
  118. {
  119. public:
  120.     word ldelay;
  121.     word lfb;
  122.     word rdelay;
  123.     word rfb;
  124.     byte dry;
  125.     word xover;
  126.     word lin;
  127.     word rin;
  128. };
  129.  
  130. #pragma pack()
  131.  
  132. CMachineInfo const MacInfo = 
  133. {
  134.     MT_EFFECT,                                // type
  135.     MI_VERSION,                                // always
  136.     MIF_MONO_TO_STEREO,                        // flags (MIF_MONO_TO_STEREO, MIF_PLAYS_WAVES)
  137.     0,                                        // min tracks
  138.     0,                                        // max tracks
  139.     8,                                        // numGlobalParameters
  140.     0,                                        // numTrackParameters
  141.     pParameters,                            // pointer to parameters
  142.     0,                                        // numAttributes            
  143.     NULL,                                    // pointer to attributes
  144.     "FUK O-Delay",                            // name
  145.     "O-Delay",                                // short name
  146.     "Frequency UnKnown",                    // author
  147.     NULL
  148. };
  149.  
  150.  
  151. class mi : public CMachineInterface
  152. {
  153. public:
  154.     mi();
  155.     virtual ~mi();
  156.  
  157.     virtual void Init(CMachineDataInput * const pi);
  158.     virtual void Tick();
  159.     virtual bool WorkMonoToStereo(float *pin, float *pout, int numsamples, int const mode);
  160.     char const* DescribeValue(int const param, int const value); 
  161.  
  162.  
  163.  
  164. private:
  165.     float dummy;
  166.     int count, rate;
  167.     float *lringbuff, *rringbuff;
  168.     int lrbpos, rrbpos;
  169.     int lrblen, rrblen;
  170.     float leftFB, rightFB;
  171.     float dryAmt;
  172.     float XOverAmt;
  173.     float leftIn, rightIn;
  174.  
  175.     gvals gval;
  176.  
  177. };
  178.  
  179.  
  180. DLL_EXPORTS
  181.  
  182.  
  183. mi::mi()
  184. {
  185.     GlobalVals = &gval;
  186.     AttrVals = NULL;
  187.     TrackVals = NULL;
  188. }
  189.  
  190.  
  191. mi::~mi()
  192. {
  193.     // Deallocate stuff
  194. }
  195.  
  196.  
  197. void mi::Init(CMachineDataInput * const pi)
  198. {
  199.     rate = pMasterInfo->SamplesPerSec;
  200.     lringbuff = new float[44100];
  201.     lrbpos = 0;
  202.     lrblen = 44100;
  203.     rringbuff = new float[44100];
  204.     rrbpos = 0;
  205.     rrblen = 44100;
  206. }
  207.  
  208.  
  209. void mi::Tick()
  210. {
  211.     if (gval.ldelay != paraLDelay.NoValue)
  212.     {
  213.         lrblen = gval.ldelay / 16.0 * pMasterInfo->SamplesPerTick;
  214.         lringbuff = new float[lrblen];
  215.         lrbpos = 0;
  216.     }
  217.  
  218.     if (gval.lfb != paraLFB.NoValue)
  219.         leftFB = (gval.lfb - 200) / 100.0;
  220.  
  221.     if (gval.rdelay != paraRDelay.NoValue)
  222.     {
  223.         rrblen = gval.rdelay / 16.0 * pMasterInfo->SamplesPerTick;
  224.         rringbuff = new float[rrblen];
  225.         rrbpos = 0;
  226.     }
  227.  
  228.     if (gval.rfb != paraRFB.NoValue)
  229.         rightFB = (gval.rfb - 200) / 100.0;
  230.  
  231.     if (gval.dry != paraDryAmt.NoValue)
  232.         dryAmt = gval.dry / 100.0;
  233.  
  234.     if (gval.xover != paraXOver.NoValue)
  235.         XOverAmt = (gval.xover - 200) / 100.0;
  236.  
  237.     if (gval.lin != paraLIn.NoValue)
  238.     leftIn = (gval.lin - 200) / 100.0;
  239.  
  240.     if (gval.rin != paraRIn.NoValue)
  241.     rightIn = (gval.rin - 200) / 100.0;
  242.  
  243. }
  244.  
  245.  
  246. bool mi::WorkMonoToStereo(float *pin, float *pout, int numsamples, int const mode)
  247. {
  248.     if (mode == WM_NOIO)
  249.     {
  250.         return false;
  251.     }
  252.  
  253.     if (mode == WM_READ || mode == WM_WRITE)
  254.     {    
  255.         do
  256.         {
  257.             lringbuff[(lrbpos + lrblen - 1) % lrblen] = rringbuff[rrbpos] * XOverAmt + lringbuff[lrbpos] * leftFB;
  258.             *pout = lringbuff[lrbpos];
  259.             pout++;
  260.             rringbuff[(rrbpos + rrblen - 1) % rrblen] = lringbuff[lrbpos] * XOverAmt + rringbuff[rrbpos] * rightFB;
  261.             *pout = rringbuff[rrbpos];
  262.             pout++;
  263.             pin++;
  264.             lrbpos = (++lrbpos) % lrblen;
  265.             rrbpos = (++rrbpos) % rrblen;
  266.         }
  267.         while (--numsamples);
  268.     }
  269.  
  270.     if (mode == WM_READWRITE)
  271.     {
  272.         do
  273.         {
  274.             lringbuff[(lrbpos + lrblen - 1) % lrblen] = rringbuff[rrbpos] * XOverAmt + lringbuff[lrbpos] * leftFB + *pin * leftIn;
  275.             *pout = lringbuff[lrbpos] + dryAmt * *pin;
  276.             pout++;
  277.             rringbuff[(rrbpos + rrblen - 1) % rrblen] = lringbuff[lrbpos] * XOverAmt + rringbuff[rrbpos] * rightFB + *pin * rightIn;
  278.             *pout = rringbuff[rrbpos] + dryAmt * *pin;
  279.             pout++;
  280.             pin++;
  281.             lrbpos = (++lrbpos) % lrblen;
  282.             rrbpos = (++rrbpos) % rrblen;
  283.         }
  284.         while (--numsamples);
  285.     }
  286.  
  287.     return true;
  288. }
  289.  
  290. char const* mi::DescribeValue(int const param, int const value)
  291. {
  292.     static char str[12];
  293.     int temp1, temp2;
  294.  
  295.     if (param == 0 || param == 2)
  296.     {
  297.         temp1 = value/16;
  298.         temp2 = value%16;
  299.         sprintf (str,"%d %d/16 ticks", temp1, temp2);
  300.     }
  301.  
  302.     if (param == 1 || param == 3 || param == 5 || param == 6 ||
  303.         param == 7)
  304.     {
  305.         sprintf (str, "%d%%", value - 200);
  306.     }
  307.  
  308.     if (param == 4)
  309.     {
  310.         sprintf (str, "%d%%", value);
  311.     }
  312.  
  313.     return str;
  314. }
  315.  
  316.